===== 第 1 页 =====
第2章 Java编程基础
· Java中的变量与常量
· 选择结构语句
· 数组
· Java的基本语法
· Java中的运算符
· 循环结构语句
===== 第 2 页 =====
学习目标
掌握
熟悉
了解
Java语言运算符的使用
Java结构语句的使用
Java中数组的定义
与使用
1
2
Java语言中的变量
与常量
Java的基本语法格式
3
===== 第 3 页 =====
Java的基本语法
2.1
☞点击查看本小节知识架构
Java中的变量与常理
2.2
☞点击查看本小节知识架构
Java中的运算符
2.3
选择结构语句
2.4
目录
☞点击查看本小节知识架构
☞点击查看本小节知识架构
===== 第 4 页 =====
循环结构语句
2.5
数组
2.6
☞点击查看本小节知识架构
目录
☞点击查看本小节知识架构
===== 第 5 页 =====
2.1  Java的基本语法
返回目录
2.1.1
2.1.2
Java的基本语法格式
Java中的注释
知识架构
2.1.3
2.1.4
Java中的关键字
Java中的标识符
===== 第 6 页 =====
2.2  Java中的变量与常量
2.2.1
2.2.2
2.2.3
变量的定义
变量的数据类型
变量的类型转换
返回目录
知识架构
2.2.4
2.2.5
变量的作用域
Java中的常量
===== 第 7 页 =====
2.3  Java中的运算符
返回目录
2.3.1
2.3.2
算术运算符
赋值运算符
知识架构
2.3.3
2.3.4
比较运算符
逻辑运算符
===== 第 8 页 =====
2.3  Java中的运算符
返回目录
2.3.5
2.3.6
位运算符
条件运算符
知识架构
2.3.7
运算符的优先级
===== 第 9 页 =====
2.4  选择结构语句
返回目录
2.4.1
2.4.2
if条件语句
Switch条件语句
知识架构
===== 第 10 页 =====
2.5  循环结构语句
返回目录
2.5.1
2.5.2
While循环语句
do...while循环语句
知识架构
2.5.3
2.5.4
for循环语句
循环嵌套
2.5.5
跳转语句（break、continue）
===== 第 11 页 =====
2.6  数组
返回目录
2.6.1
2.6.2
数组的定义
数组的常见操作
知识架构
2.6.3
多维数组
===== 第 12 页 =====
[修饰符] class 类名 {
程序代码
}
2.1.1 Java的基本语法格式
2.1 Java的基本语法
Java基本语法格式如下：
修饰符用于限定类的访问权限（可以省略）
声明类，必须使用class关键字
类中定义的功能代码
定义的类名称，通常使用首字母大写的形式
===== 第 13 页 =====
2.1 Java的基本语法
编写Java程序代码时，需要特别注意几个关键点：
Java中的程序可分为结构定义语句和功能执行语句。
结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能
每条功能执行语句的结尾都必须用英文分号（;）结束
功能执行语句代码示例：
System.out.println("这是第一个Java程序！");
===== 第 14 页 =====
2.1 Java的基本语法
Java语言是严格区分大小写的。
在编写Java代码时，为了便于阅读，通常会使用一种良好的格式进行排版。
public class HelloWorld {
public static void main(String[] args)
System.out.println("这是第一个Java程序！");
}
}
===== 第 15 页 =====
2.1 Java的基本语法
Java程序中一个连续的字符串不能直接分开在两行中书写。
如果为了便于阅读，想将一个太长的字符串分开在两行中书写，可以先将这个字符串分成两个字符串，然后用加号（+）将这两个字符串拼接起来，在加号（+）处断行。
System.out.println("这是第一个" +
"Java程序！");
===== 第 16 页 =====
2.1 Java的基本语法
2.1.2 Java中的注释
Java注释有什么作用？
作用：在编写程序时，为了使代码易于阅读，通常会在实现功能的同时为代码添加一些注释。注释是对程序的某个功能或者某行代码的解释说明，它能够让开发者在后期阅读和使用代码时能更容易理解代码的作用。
说明：注释只在Java源文件中有效，在编译程序时编译器会忽略这些注释信息，不会将其编译到class字节码文件中。
===== 第 17 页 =====
2.1 Java的基本语法
单行注释
单行注释通常用于对程序中的某一行代码进行解释，用符号“//”表示，“//”后面为被注释的内容。
2.1.2 Java中的注释——注释类型
int c = 10;      // 定义一个整型变量c
===== 第 18 页 =====
2.1 Java的基本语法
多行注释
多行注释顾名思义就是可以同时为多行内容进行统一注释，它以符号“/*”开头，并以符号“*/”结尾。
/* 定义一个整形变量x
将5赋值给变量x */
int x;
x = 5;
===== 第 19 页 =====
2.1 Java的基本语法
文档注释
文档注释通常是对程序中某个类或类中的方法进行的系统性的解释说明，开发人员可以使用JDK提供的javadoc工具将文档注释提取出来生成一份API帮助文档。文档注释以符号“/**”开头，并以符号“*/”结尾。
/**
* Title：HelloWorld类
* @author srx
* @version 1.0
*/
public class HelloWorld {
/**
* 这是一个main()方法入口
* @param args 参数名
*/
public static void main(String[] args){
System.out.println("这是第一个Java程序！");
}
}
===== 第 20 页 =====
2.1 Java的基本语法
在Java中，有的注释可以嵌套使用，有的则不可以。
多行注释“/*…*/”中可以嵌套使用单行注释“//”。
多行注释“/*…*/”中不能嵌套使用多行注释“/*…*/” 。
/*  int c = 10;   // 定义一个整型的c
int x = 5; */
/*
/*int c = 10;*/
int x=5;
*/
脚
下
留
心
===== 第 21 页 =====
2.1 Java的基本语法
abstract | assert | boolean | break | byte
case | catch | char | class | const
continue | default | do | double | else
enum | extends | final | finally | float
for | goto | if | implements | import
instanceof | int | interface | long | native
new | package | private | protected | public
return | strictfp | short | static | super
switch | synchronized | this | throw | throws
transient | try | void | volatile | while
2.1.3 Java中的关键字
关键字（Keyword）是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。JDK 8中有50个关键字，这些关键字都是小写的。
===== 第 22 页 =====
2.1 Java的基本语法
2.1.4 Java中的标识符
定义：在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
组成：标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，也不能是Java中的关键字。
===== 第 23 页 =====
2.1 Java的基本语法
2.1.4 Java中的标识符
合法标识符示例：
username
username123
user_name
_userName
$username
非法标识符示例：
123username		// 不能以数字开头
class			// 不能是关键字
Hello World		// 不能包含空格特殊字符
===== 第 24 页 =====
2.1 Java的基本语法
包名所有字母一律小写。例如：com.itheima.example01。
类名和接口名每个单词的首字母都要大写。例如：ArrayList、Iterator。
常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。
变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。
在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如：使用userName表示用户名，password表示密码。
2.1.4 Java中的标识符——通用规范
===== 第 25 页 =====
2.2 Java中的变量与常量
定义：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
2.2.1 变量的定义
===== 第 26 页 =====
变量类型 变量名 [= 初始值];
2.2 Java中的变量与常量
变量的基本语法格式如下：
变量类型决定了变量的数据性质、范围、存储在内存中所占的字节数以及可以进行的合法操作
变量名必须是一个合法的标识符
[]中的内容是可选项，即在定义变量的同时，可以对该变量进行初始化赋值
===== 第 27 页 =====
2.2 Java中的变量与常量
说明：上述代码中，第一行代码的作用是定义了两个int类型的变量x和y，也就相当于分配了两块内存单元，在定义变量的同时为变量x分配了一个初始值0，而变量y没有分配初始值。
变量的定义示例：
int x = 0,y;
y = x+3;
===== 第 28 页 =====
2.2 Java中的变量与常量
y = x+3;
变量x和y在内存中的状态变化图：
===== 第 29 页 =====
2.2 Java中的变量与常量
Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须先声明变量的数据类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序在编译期间就会出现类型匹配错误的问题。
2.2.2 变量的数据类型
===== 第 30 页 =====
2.2 Java中的变量与常量
在Java中变量的数据类型分为两种：基本数据类型和引用数据类型。
===== 第 31 页 =====
2.2 Java中的变量与常量
整数类型变量
整数类型变量用来存储整数数值，即没有小数部分的值。
类型名 | 占用空间 | 取值范围
byte | 8位（1个字节） | -27  ～ 27-1
short | 16位（2个字节） | -215  ～ 215-1
int | 32位（4个字节） | -231  ～ 231-1
long | 64位（8个字节） | -263  ～ 263-1
===== 第 32 页 =====
2.2 Java中的变量与常量
注意：在为一个long类型的变量赋值时，所赋值的后面要加上一个字母“L”（或小写“l”），说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母“L”（或小写“l”）。
long num = 2200000000L;   // 所赋的值超出了int型的取值范围，后面必须加上字母L
long num = 198L;                 // 所赋的值未超出int型的取值范围，后面可以加上字母L
long num = 198;              // 所赋的值未超出int型的取值范围，后面可以省略字母L
===== 第 33 页 =====
2.2 Java中的变量与常量
浮点数类型变量用来存储小数数值。
浮点数类型变量
类型名 | 占用空间 | 取值范围
float | 32位（4个字节） | 1.4E-45 ～ 3.4E+38，-1.4E-45  ～ -3.4E+38
double | 64位（8个字节） | 4.9E-324 ～ 1.7E+308，-4.9E-324  ～ -1.7E+308
===== 第 34 页 =====
2.2 Java中的变量与常量
注意：一个小数会被默认为double类型的值，因此在为一个float类型的变量赋值时，所赋值的后面一定要加上字母“F”（或者小写“f”），而为double类型的变量赋值时，可以在所赋值的后面加上字符“D”（或小写“d”），也可以不加。
在程序中也可以为一个浮点数类型变量赋予一个整数数值：
float f = 123.4f;           // 为一个float类型的变量赋值，后面必须加上字母f或F
double d1 = 199.3d;   // 为一个double类型的变量赋值，后面可以加上字母d或D
double d2 = 100.1;     // 为一个double类型的变量赋值，后面可以省略字母d或D
float f = 100; 	       // 声明一个float类型的变量并赋整数值
double d = 100;          // 声明一个double类型的变量并赋整数值
===== 第 35 页 =====
2.2 Java中的变量与常量
字符类型变量
字符类型变量用于存储一个单一字符，在Java中用char表示。
Java中每个char类型的字符变量都会占用2个字节。
在给char类型的变量赋值时，需要用一对英文半角格式的单引号（' '）把字符括起来，如'a'，也可以将char类型的变量赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为'a'。
char c = 'a';              // 为一个char类型的变量赋值字符'a'
char ch = 97;           // 为一个char类型的变量赋值整数97，相当于赋值字符'a'
===== 第 36 页 =====
2.2 Java中的变量与常量
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。
布尔类型变量
boolean flag = false;    // 声明一个boolean类型的变量，初始值为false
flag = true; 	        // 改变flag变量的值为true
===== 第 37 页 =====
2.2 Java中的变量与常量
说明：在程序中，当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
分类：根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。
2.2.3 变量的类型转换
===== 第 38 页 =====
2.2 Java中的变量与常量
自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。当把一个类型取值范围小的数值直接赋给另一个取值范围大的数据类型变量时，系统就会进行自动类型转换。
将小瓶水倒入大瓶
自动类型转换就好比将小瓶水倒入到大瓶的换装过程。我们将小瓶水倒入到大瓶中时，由于小瓶的容量比大瓶的容量小，所以倒入的水永远不可能溢出大瓶。
自动类型转换
===== 第 39 页 =====
2.2 Java中的变量与常量
Java中支持的不同数据类型之间的自动转换，如下图所示。
byte b = 3;
int x = b;            // 程序把byte类型的变量b转换成了int类型，无需特殊声明
double y = x;     // 将int类型的变量x转换成double类型，无需特殊声明
===== 第 40 页 =====
2.2 Java中的变量与常量
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
将大瓶水倒入小瓶
强制类型转换就好比将大瓶水倒入到小瓶中一样，如果大瓶中的水的容量小于小瓶的大小，那么水是可以完全倒入的；否则多出来的水就会溢出。所以系统默认不支持这种行为，只能由开发者自己决定是否进行强制类型转换。
强制类型转换
===== 第 41 页 =====
2.2 Java中的变量与常量
强制类型转换语法格式：
目标类型  变量名 = （目标类型）值;
注意：在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转换情况，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。
案例演示（参考教材文件2-2）
===== 第 42 页 =====
2.2 Java中的变量与常量
原因分析：出现丢失精度的原因是，变量b为int类型，在内存中占用4个字节，而byte类型的数据在内存中占用1个字节，当将变量b的类型强转为byte类型后，前面3个高位字节的数据已经丢失，这样数值就发生了改变。
===== 第 43 页 =====
2.2 Java中的变量与常量
表达式类型自动提升
所谓表达式是指由变量和运算符组成的一个算式。变量在表达式中进行运算时，也有可能发生自动类型转换，这就是表达式数据类型的自动提升，如byte、short和char类型的变量在运算期间类型会自动提升为int，然后再进行运算。
案例演示（参考教材2.2.3小节——多学一招）
多
学
一
招
===== 第 44 页 =====
2.2 Java中的变量与常量
注
注
定义：变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
2.2.4 变量的作用域
案例演示（参考教材文件2-4）
===== 第 45 页 =====
2.2 Java中的变量与常量
注
注
定义：常量就是在程序中固定不变的值，是不能改变的数据。例如数字1、字符'a'、浮点数3.2等。
分类：在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。
2.2.5 Java中的常量
===== 第 46 页 =====
2.2 Java中的变量与常量
注
注
整型常量是整数类型的数据，有二进制、八进制、十进制和十六进制4种。
二进制：由数字0和1 组成的数字序列。在JDK 7以后，允许使用二进制字面值来表示整数，此时二进制数值前面要以0b或0B开头，目的是为了和十进制进行区分，如：0b01101100、0B10110101。
八进制：以0开头，并且其后由0 ~7范围（包括0和7）内的整数组成的数字序列，如：0342。
十进制：由数字0~9范围（包括0和9）内的整数组成的数字序列。如：198。
十六进制：以0x或者0X开头，并且其后由0~9、A~F（包括0和9、A和F）组成的字符序列，如：0x25AF。
整型常量
===== 第 47 页 =====
2.2 Java中的变量与常量
注
注
浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。
注意：单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何后缀，此时Java虚拟机会将浮点数默认识别为double双精度浮点数。
浮点数常量
2e3f  3.6d  0f  3.84d  5.022e+23f
===== 第 48 页 =====
2.2 Java中的变量与常量
注
注
字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（' '）引起来，它可以是英文字母、数字、标点符号以及由转义序列来表示的特殊字符。
字符常量
'a'  '1'  '&'  '\r'
===== 第 49 页 =====
2.2 Java中的变量与常量
注
注
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）引起来。
字符串常量
"HelloWorld"   "123"   "Welcome \n XXX" ""
===== 第 50 页 =====
2.2 Java中的变量与常量
注
注
布尔常量即布尔类型的两个值true和false，该常量用于区分一个条件的真假。
注
注
null常量只有一个值null，表示对象的引用为空。
布尔常量
null常量
===== 第 51 页 =====
2.2 Java中的变量与常量
注
注
定义：Java中的常量，其实就是特殊的变量，也是固定不变的量，有且只能进行一次赋值。
语法：Java中定义常量的语法也非常简单，只需要在定义变量的语法基础上加上一个final关键字修饰即可。
Java中的常量
===== 第 52 页 =====
2.2 Java中的变量与常量
注
注
Java中的常量的语法格式：
Java中的常量
final 常量类型 常量名 [= 初始值];
Java中的常量的使用示例：
final int a=0, b;     // 定义一个int类型的常量a和b，并为常量a初始化赋值0
b= 1;		// 后续为常量b赋值
===== 第 53 页 =====
2.2 Java中的变量与常量
转义符——反斜杠（\）
定义：在字符常量中，反斜杠（\）是一个特殊的字符，被称为转义符，它的作用是用来转义紧随其后的一个字符。
说明：转义后的字符通常用于表示一个不可见的字符或具有特殊含义的字符，例如“\n”表示换行。
多
学
一
招
===== 第 54 页 =====
2.2 Java中的变量与常量
转义符——反斜杠（\）
常见转义字符：
\r ：表示回车，将光标定位到当前行的开头，不会跳到下一行。
\n ：表示换行，换到下一行的开头。
\t ：表示制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样。
\b ：表示退格符号，就像键盘上的Backspace。
多
学
一
招
===== 第 55 页 =====
2.2 Java中的变量与常量
转义符——反斜杠（\）
常见转义字符：
\‘ ：表示单引号字符，表示字符的开始和结束，如果直接写单引号字符（'）,程序会认为前两个是一对，会报错，因此需要使用转义（\'）。
\“ ：表示双引号字符，表示字符串的开始和结束，包含在字符串中的双引号需要转义，比如"he says,\"thank you\"."。
\\ ：表示反斜杠转义字符，由于在Java代码中的斜杠（\）是转义符，因此需要表示字面意义上的\，就需要使用双斜杠\\。
多
学
一
招
===== 第 56 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
1．十进制和二进制之间的转换
（1）十进制转二进制
转换方法：十进制转换成二进制就是一个除以2取余数的过程。把要转换的数，除以2，得到商和余数，将商继续除以2，直到商为0。最后将所有余数倒序排列，得到数就是转换结果。
多
学
一
招
===== 第 57 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
转换方法：要从右到左用二进制位上的每个数去乘以2的相应次方，例如，将最右边第一位的数乘以2的0次方，第二位的数乘以2的1次方，第n位的数乘以2的n-1次方，然后把所有乘得的结果相加，得到的结果就是转换后的十进制。
（2）二进制转十进制
多
学
一
招
===== 第 58 页 =====
2.2 Java中的变量与常量
以二进制数01100100转换为十进制为例进行说明，转换方式如下：
或者（0乘以多少都是0，可以进行简写）：
（2）二进制转十进制
0 * 20 + 0 * 21  + 1 * 22 + 0 * 23 + 0 * 24 + 1 * 25 + 1 * 26+ 0 * 27 = 100
1 * 22 + 1 * 25 + 1 * 26 = 100
整型常量进制间的转换
多
学
一
招
===== 第 59 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
（1）二进制转八进制
转换方法：二进制转八进制时，首先需要将二进制数自右向左每三位分成一段（不足三位的，在左侧补0），然后将二进制数每段的三位数转为八进制的一位。
二进制 | 八进制
000 | 0
001 | 1
010 | 2
011 | 3
100 | 4
101 | 5
110 | 6
111 | 7
二进制与八进制数值转换表：
1．二进制和八进制、十六进制之间的转换
多
学
一
招
===== 第 60 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
将一个二进制数00101010转为八进制，具体步骤如下：
每三位分成一段，结果为：000 101 010
将每段的数值分别查表替换，结果如下：
000  0
101  5
010  2
将替换的结果进行组合，转换的结果为:052(注意八进制必须以0开头0)
多
学
一
招
===== 第 61 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
（2）二进制转十六进制
转换方法：二进制转十六进制，与转八进制类似，不同的是要将二进制数每四位分成一段（不足四位的，在左侧补0），然后通过查表将二进制数每段的四位数转换为八进制的每一位即可。
二进制与十六进制数值转换表：
二进制 | 十六进制 |  | 二进制 | 十六进制
0000 | 0 |  | 1000 | 8
0001 | 1 |  | 1001 | 9
0010 | 2 |  | 1010 | A
0011 | 3 |  | 1011 | B
0100 | 4 |  | 1100 | C
0101 | 5 |  | 1101 | D
0110 | 6 |  | 1110 | E
0111 | 7 |  | 1111 | F
多
学
一
招
===== 第 62 页 =====
2.2 Java中的变量与常量
整型常量进制间的转换
每四位分成一段，结果为：1010 0101
将每段的数值分别查表替换，结果如下：
1010  A
0101  5
将替换的结果进行组合，转换的结果为:0xA5或0XA5（注意十六进制必须以0x或者0X开头）
将一个二进制数10100101转为十六进制，具体步骤如下：
多
学
一
招
===== 第 63 页 =====
2.3 Java中的运算符
所谓运算符就是专门用于告诉程序执行特定运算或逻辑操作的符号。
赋值
运算符
位
运算符
条件
运算符
比较
运算符
逻辑
运算符
算术
运算符
什么是运算符？
===== 第 64 页 =====
2.3 Java中的运算符
算术运算符：
Java中的算术运算符就是用来处理四则运算的符号。
也是最简单和最常用的运算符号。
2.3.1 算术运算符
===== 第 65 页 =====
2.3 Java中的运算符
运算符 | 运算 | 范例 | 结果
+ | 正号 | +3 | 3
- | 负号 | b=4;-b; | -4
+ | 加 | 5+5 | 10
- | 减 | 6-4 | 2
* | 乘 | 3*4 | 12
/ | 除（即算数中整除的结果） | 7/5 | 1
% | 取模（即算术中的求余数） | 7%5 | 2
++ | 自增（前） | a=2;b=++a; | a=3;b=3;
++ | 自增（后） | a=2;b=a++; | a=3;b=2;
-- | 自减（前） | a=2;b=--a; | a=1;b=1;
-- | 自减（后） | a=2;b=a--; | a=1;b=2;
算术运算符分类说明：
===== 第 66 页 =====
2.3 Java中的运算符
注意事项：
在进行自增（++）和自减（--）的运算时，如果运算符（++或--）放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算。
在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数；如果除法运算有小数参与，得到的结果会是一个小数。
在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
===== 第 67 页 =====
2.3 Java中的运算符
赋值运算符：
赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量。
它将运算符右边的值赋给左边的变量。
2.3.2 赋值运算符
===== 第 68 页 =====
2.3 Java中的运算符
运算符 | 运算 | 范例 | 结果
= | 赋值 | a=3;b=2; | a=3;b=2;
+= | 加等于 | a=3;b=2;a+=b; | a=5;b=2;
-= | 减等于 | a=3;b=2;a-=b; | a=1;b=2;
*= | 乘等于 | a=3;b=2;a*=b; | a=6;b=2;
/= | 除等于 | a=3;b=2;a/=b; | a=1;b=2;
%= | 模等于 | a=3;b=2;a%=b; | a=1;b=2;
赋值运算符分类说明：
===== 第 69 页 =====
2.3 Java中的运算符
注意事项：
在Java中可以通过一条赋值语句对多个变量进行赋值。
在赋值运算符中，除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x = x + 3，首先会进行加法运算x+3，再将运算结果赋值给变量x。其余的-=、*=、/=、%=赋值运算符都可依此类推。
===== 第 70 页 =====
public class Example05 {
public static void main(String[] args) {
short s = 3;
int i = 5;
s += i;
System.out.println("s = " + s);
}
}
2.3 Java中的运算符
赋值运算符中强制类型转换的自动实现
在使用+=、-=、*=、/=、%= 赋值运算符时，需要进行的强制类型转换会自动完成，程序不需要做任何显式地声明。
√
多
学
一
招
===== 第 71 页 =====
2.3 Java中的运算符
比较运算符：
用来对两个数值或变量进行比较。
其结果是布尔类型的true或false。
2.3.3 比较运算符
===== 第 72 页 =====
2.3 Java中的运算符
运算符 | 运算 | 范例 | 结果
== | 相等于 | 4 == 3 | false
!= | 不等于 | 4 != 3 | true
< | 小于 | 4 < 3 | false
> | 大于 | 4 > 3 | true
<= | 小于等于 | 4 <= 3 | false
>= | 大于等于 | 4 >= 3 | true
比较运算符分类说明：
===== 第 73 页 =====
2.3 Java中的运算符
逻辑运算符：
是用于对布尔类型的值或表达式进行操逻辑判断的符号。
其返回值类型是布尔类型。
2.3.4 逻辑运算符
===== 第 74 页 =====
2.3 Java中的运算符
逻辑运算符分类说明：
运算符 | 运算 | 范例 | 结果
& | 与 | a & b | a和b都为true，结果为true，否则为false
| | 或 | a | b | a和b中只要有一个为true，则结果为true，否则为false
^ | 异或 | A ^ b | a与b不同，结果为true，否则为false
! | 非 | ! A | 若a为false，结果为true，否则相反
&& | 短路与 | a && b | a和b都为true，结果为true，否则为false
|| | 短路或 | a || b | a和b中只要有一个为true，则结果为true，否则为false
===== 第 75 页 =====
2.3 Java中的运算符
注意事项：
逻辑运算符可以针对结果为布尔值的表达式进行逻辑运算。如：5 > 3 && 1 != 0的结果为true。
运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。
“&”和“&&”的区别：在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&”被称作短路与。
案例演示（参考教材文件2-6）
===== 第 76 页 =====
2.3 Java中的运算符
运算符“|”和“||”都表示或操作，当运算符任何一边的操作数或表达式为true时，其结果为true，当两边的值都为false时，其结果才为false。同与操作类似，“||”表示短路或，当运算符“||”的左边为true时，右边的表达式不会进行运算。
运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。当两边布尔值不相同时，其结果为true。
注意事项：
===== 第 77 页 =====
2.3 Java中的运算符
位运算符：
是针对二进制数的每一位进行运算的符号。
它专门针对数字0和1进行操作。
2.3.5 位运算符
===== 第 78 页 =====
2.3 Java中的运算符
运算符 | 运算 | 范例 | 结果
& | 按位与 | a & b | a和b每一位进行“与”操作后的结果
| | 按位或 | a | b | a和b每一位进行“或”操作后的结果
~ | 取反 | ~ a | a的每一位进行“非”操作后的结果
^ | 按位异或 | a ^ b | a和b每一位进行“异或”操作后的结果
<< | 左移 | a << b | 将a左移b位，右边空位用0填充
>> | 右移 | a >> b | 将a右移b位，丢弃被移出位，左边最高位用0或1填充
>>> | 无符号右移 | a >>>b | 将a右移b位，丢弃被移出位，左边最高位用0填充
说明：位运算符本质都是针对二进制数0和1进行运算的，在使用位运算符时，都会先将操作数转换成二进制数的形式进行位运算，然后将得到的结果再转换成想要的进制数。其中，1表示true，0表示false。
位运算符分类说明：
===== 第 79 页 =====
2.3 Java中的运算符
按位与
按位或
针对byte类型的数，也就是一个字节大小的数进行演示：
2.3.5 位运算符——演示说明
===== 第 80 页 =====
2.3 Java中的运算符
取反
按位异或
2.3.5 位运算符——演示说明
===== 第 81 页 =====
2.3 Java中的运算符
左移
右移
2.3.5 位运算符——演示说明
===== 第 82 页 =====
2.3 Java中的运算符
无符号右移
2.3.5 位运算符——演示说明
===== 第 83 页 =====
2.3 Java中的运算符
条件运算符：
也称作三元运算符（或三目运算符），由符号“? :”组合构成。
对布尔类型的表达式判断，如果为true，就执行冒号“:”前面的表达式，否者执行后面的表达式。
2.3.6 条件运算符
===== 第 84 页 =====
2.3 Java中的运算符
规则：先判断boolean_expr的值，如果为true，就执行表达式true_statement，否者执行表达式false_statement。
条件运算符的语法格式：
(boolean_expr) ? true_statement : false_statement;
条件运算符的使用示例：
int store = 5;
System.out.println(store <=0 ? "没有库存啦！" : "库存量为："+store);
// 输出结果为 “库存量为：5”
===== 第 85 页 =====
2.3 Java中的运算符
运算符的优先级：
指的是在表达式中各个运算符参与运算的先后顺序
例如：先乘除，后加减
2.3.7 运算符的优先级
===== 第 86 页 =====
2.3 Java中的运算符
优先级 | 运算符
1 | .  []  ()
2 | ++  --  ~  !
3 | *  /  %
4 | +  -
5 | <<  >>  >>>
6 | <  >  <=  >=
7 | ==  !=
8 | &
9 | ^
10 | |
11 | &&
12 | ||
13 | ?:
14 | =  *=  /=  %=  +=  -=  <<=  >>=  >>>=  &=  ^=  |=
2.3.7 运算符的优先级——优先级列表
===== 第 87 页 =====
2.4 选择结构语句
在实际生活中经常需要作出一些判断，比如开车来到一个十字路口，这时需要对红绿灯进行判断，如果前面是红灯，就停车等候，如果是绿灯，就通行。Java中有一种特殊的语句叫做选择结构语句，它也需要对一些条件作出判断，从而决定执行哪一段代码。
Java中的选择结构语句分为：if条件语句和switch条件语句。
===== 第 88 页 =====
2.4 选择结构语句
If语句
if语句是指如果满足某种条件，就进行某种处理。
If条件语句分类：
if…else语句
if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。
if…else if…else语句
if…else if…else语句用于对多个条件进行分支判断，从而进行多种不同的处理。
2.4.1 if条件语句
===== 第 89 页 =====
2.4 选择结构语句
例如，如果一个人的年龄不满18周岁，那么就可以判定这个人是未成年人。这句话可以通过下面的一段伪代码来描述：
“如果”相当于if，“年龄不满18周岁”是判断条件，“此人是未成年人！”是执行语句
if语句
如果年龄不满18周岁
此人是未成年人
if (年龄不满18岁) {
此人是未成年人！
}
===== 第 90 页 =====
2.4 选择结构语句
if (判断条件){
执行语句
}
if语句语法格式：
if语句执行流程：
案例演示（参考教材文件2-7）
===== 第 91 页 =====
2.4 选择结构语句
例如，要判断一个正整数的奇偶，如果该数字能被2整除则是一个偶数，否则该数字就是一个奇数，就可以使用if...else语句。
if...else语句
if (判断条件){
执行语句1
...
}else{
执行语句2
...
}
if...else语句语法格式：
===== 第 92 页 =====
2.4 选择结构语句
if...else语句的执行流程：
===== 第 93 页 =====
2.4 选择结构语句
小提示
if...else语句还可以与前面学习的条件运算符“？:”进行替换。
if (num % 2 == 0) {
// 判断条件成立，num能被2整除
System.out.println(num+"是一个偶数");
} else {
// 判断条件不成立，num不能被2整除
System.out.println(num+"是一个奇数");
}
System.out.println(num % 2 == 0 ? num+"是一个偶数" :num+"是一个奇数" );
}
===== 第 94 页 =====
2.4 选择结构语句
例如，对一个学生的考试成绩进行等级划分：如果分数大于80分，那么等级为优；否则，如果分数大于70分，那么等级为良；否则，如果分数大于60分，那么等级为中；否则，等级为差，就可以使用if...else if...else语句。
if...else if...else语句
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
if...else if ...else语句语法格式：
===== 第 95 页 =====
2.4 选择结构语句
案例演示（参考教材文件2-9）
if...else...else语句的执行流程：
===== 第 96 页 =====
2.4 选择结构语句
定义：switch 条件语句也是一种很常用的选择结构语句，它由一个switch控制表达式和多个case关键字组成。
说明：与if条件语句不同的是，switch 条件语句的控制表达式结果类型只能是byte、short、char、int、enum枚举以及String类型，而不能是boolean类型。
2.4.2 switch条件语句
===== 第 97 页 =====
2.4 选择结构语句
switch语句语法格式：
switch (控制表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
===== 第 98 页 =====
2.4 选择结构语句
规则： switch语句将控制表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的执行语句，并通过break关键字跳出该switch语句；如果搜索完所有case中的目标值仍没找到任何匹配的值，就会执行default后的语句。
===== 第 99 页 =====
2.4 选择结构语句
案例演示（参考教材文件2-10）
注意
在使用switch条件语句时，需要特别注意：第一，switch条件语句后{}中的多个case以及default标签顺序可以随机，并不影响程序的执行结果；第二，在case和default标签中的执行语句后务必都加上break关键字，用于执行完语句后跳出当前的switch条件语句，否则，程序会接着执行后续的执行语句，直到遇到break关键字或switch语句末尾为止。
===== 第 100 页 =====
2.5 循环结构语句
在实际生活中经常会将同一件事情重复做很多次，例如在做眼保健操的第四节轮刮眼眶时，会重复刮眼眶的动作；打乒乓球时，会重复挥拍的动作等。在Java中有一种特殊的语句叫做循环语句，它可以实现将一段代码重复执行，例如循环打印100位学生的考试成绩。
循环
语句分类
for循环
While循环
do…while循环
===== 第 101 页 =====
2.5 循环结构语句
定义：while循环语句和选择结构语句有些相似，都是根据条件判断来决定是否执行大括号{}内的执行语句。
区别：while语句会循环判断循环条件是否成立，只要条件成立，{}内的执行语句就会执行，直到循环条件不成立，while循环才结束。
2.5.1 while循环语句
===== 第 102 页 =====
2.5 循环结构语句
案例演示（参考教材文件2-11）
While循环语句语法格式：
while(循环条件){
执行语句
...
}
While循环语句执行流程：
===== 第 103 页 =====
2.5 循环结构语句
定义：do…while循环语句也被称为后测试循环语句，它和while循环语句的功能类似。
区别：while是先判断条件后执行循环体，而do...while会无条件执行一次循环体后再判断条件。
2.5.2 do...while循环语句
===== 第 104 页 =====
2.5 循环结构语句
案例演示（参考教材文件2-12）
do...While循环语句语法格式：
do {
执行语句
...
} while(循环条件);
do...While循环语句执行流程：
===== 第 105 页 =====
2.5 循环结构语句
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下，通常情况下可以代替while循环。
2.5.3 for循环语句
for循环语句的基本语法格式：
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
...
}
===== 第 106 页 =====
2.5 循环结构语句
案例演示（参考教材文件2-13）
for循环语句的执行流程：
===== 第 107 页 =====
2.5 循环结构语句
定义：嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。
说明：while、do…while、for循环语句都可以进行循环嵌套，并且它们之间也可以互相嵌套。在实际开发时，我们最常用的是for循环嵌套。
2.5.4 循环嵌套
===== 第 108 页 =====
2.5 循环结构语句
双层for循环的语法格式：
for(初始化表达式; 循环条件; 操作表达式) {
...
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
...
}
...
}
===== 第 109 页 =====
2.5 循环结构语句
案例演示（参考教材文件2-14）
规则：在双层for循环嵌套中，外层循环每执行一轮，都要执行完内层循环中的整个for循环，然后执行外层循环第二轮，接着再执行完内层循环中的整个for循环，以此类推，直至外层循环的循环条件不成立，才会跳出整个嵌套for循环。
===== 第 110 页 =====
2.5 循环结构语句
2.5.5 跳转语句（break、continue）
定义：跳转语句用于实现循环语句执行过程中程序流程的跳转。
分类：在Java中的跳转语句有break语句和continue语句。
===== 第 111 页 =====
2.5 循环结构语句
使用场景：在switch条件语句和循环结构语句中都可以使用break语句。
作用效果：当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构；当它出现在循环结构语句中时，作用是跳出当前循环结构语句，执行后面的代码。
案例演示（参考教材文件2-15&2-16）
break语句
===== 第 112 页 =====
2.5 循环结构语句
案例演示（参考教材文件2-17）
continue语句
使用场景：continue语句用在循环语句中。
作用效果：它的作用是终止本次循环，执行下一次循环。
===== 第 113 页 =====
2.6 数组
假设如下场景：现在需要统计某公司100名员工的工资情况，例如计算平均工资、最高工资等。
可能的办法：用前面所学的知识，程序就需要声明100个变量来分别记住每位员工的工资（这样的话非常麻烦）。
解决办法：可以使用一个数组来记住这100名员工的工资，然后对数组的元素进行操作。
===== 第 114 页 =====
2.6 数组
定义：数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
分类：一维数组和多维数组。
===== 第 115 页 =====
2.6 数组
2.6.1 数组的定义
数组定义的语法格式：
数组类型[] 数组名 = new 数组类型[数组长度];
数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素1,...};
数组类型[] 数组名 = {数组元素0,数组元素1,...};
数组定义的使用示例：
int[] ids = new int[100];
String[] names = new String[]{"张三","tom",...};
Object[] object = {"张三","tom",...};
===== 第 116 页 =====
2.6 数组
int[] ids;
ids = new int[100];
案例演示（参考教材文件2-18）
数组定义的内存变化图：
===== 第 117 页 =====
2.6 数组
Java中不同数据类型元素的初始值：
数据类型 | 默认初始值
byte、short、int、long | 0
float、double | 0.0
char | 一个空字符，即’\u0000’
boolean | false
引用数据类型 | null，表示变量不引用任何对象
===== 第 118 页 =====
2.6 数组
使用数组时，要注意下面的两种情况：
每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错（ArrayIndexOutOfBoundsException，即数组角标越界异常）。
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现错误（NullPointerException，即空指针异常）。
案例演示（参考教材文件2-20&2-21）
脚
下
留
心
===== 第 119 页 =====
2.6 数组
在程序开发中，数组的应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作，如数组的遍历、最值的获取、数组的排序等，进行详细地讲解。
案例演示（参考教材文件2-22&2-23&2-24）
2.6.2 数组的场见操作
===== 第 120 页 =====
2.6 数组
在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？
上面这种场景就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。而在程序中，比较常见的多维数组是二维数组。
2.6.3 多维数组
===== 第 121 页 =====
2.6 数组
指定二维数组的长度和每个数组的元素个数。
说明：上面的代码相当于定义了一个3*4的二维数组，这个二维数组的长度为3，可以将它看成3个int[]类型的一维数组，每个一维数组中的元素又是一个长度为4的一维数组。
int[][] arr = new int[3][4];
二维数组的定义
===== 第 122 页 =====
2.6 数组
只指定二维数组的长度，不确定每个数组的元素个数。
说明：第二种方式和第一种类似，只是数组中每个元素的长度不确定。
int[][] arr = new int[3][];
===== 第 123 页 =====
2.6 数组
直接使用嵌套大括号“{}”，对二维数组初始化赋值。
说明：上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9} 。
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
===== 第 124 页 =====
2.6 数组
说明：对二维数组中元素的操作也是通过角标的方式来完成的。
案例演示（参考教材文件2-25）
二维数组的使用
arr[0][1];        // 获取二维数组中第一个元素组的第二个元素
arr[0][1]=1;    // 对二维数组中第一个元素组的第二个元素赋值或修改
===== 第 125 页 =====
2.7 本章小结
本章主要介绍了学习Java所需的基础知识。首先介绍了Java语言的基本语法、常量、变量的定义以及一些常见运算符的使用，然后介绍了选择结构语句和循环结构语句的概念和使用，最后介绍了数组的定义及相关操作。
===== 第 126 页 =====